package model

import (
	"go.uber.org/zap"
	"goskeleton/app/global/variable"
	"time"
)

type UserModel struct {
	BaseModel
	OpenId     string `gorm:"column:open_id" json:"open_id"`
	AvatarUrl  string `gorm:"column:avatar_url" json:"avatar_url"`
	NickName   string `gorm:"column:nick_name" json:"nick_name"`
	Gender     int    `gorm:"column:gender" json:"gender"`
	Phone      string `gorm:"phone" json:"phone"`
	Email      string `gorm:"column:email" json:"email"`
	Address    string `gorm:"column:address" json:"address"`
	School     string `gorm:"column:school" json:"school"`
	StudentId  string `gorm:"column:student_id" json:"student_id"`
	IfVerified int    `gorm:"column:if_verified" json:"if_verified"`
}

func (um *UserModel) TableName() string {
	return "tb_user"
}

func CreateUserFactory1(sqlType string) *UserModel {
	return &UserModel{BaseModel: BaseModel{DB: UseDbConn(sqlType)}}
}

func (um *UserModel) Create() error {
	//创建失败
	um.DB = UseDbConn("")
	if err := um.DB.Create(&um).Error; err != nil {
		return err
	} else {
		return nil
	}
}

// 检查是否有注册的用户，如果有，则返回用户信息，如果没有，则进行注册插入
// 检查是否有注册的用户，如果有，则返回用户信息，如果没有，则进行注册插入
/*func (um *UserModel) CheckUserRegister(openId, avatarUrl, nickName string) (UserModel, error) {
	var user UserModel

	// 尝试查找用户
	result := um.DB.Where("open_id = ?", openId).First(&user)
	if result.Error != nil {
		// 如果错误是"记录不存在"，则创建新用户
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			user = UserModel{
				OpenId:     openId,
				AvatarUrl:  avatarUrl,
				NickName:   nickName,
				IfVerified: 0,
			}

			if err := um.DB.Create(&user).Error; err != nil {
				return UserModel{}, err
			}
			return user, nil
		}
		// 如果是其他错误，直接返回
		return UserModel{}, result.Error
	}

	// 如果用户已存在，直接返回
	return user, nil
}*/

func (um *UserModel) CheckUserRegister(openId, avatarUrl, nickName string) (UserModel, error) {
	var users []UserModel

	// 尝试查找用户
	result := um.DB.Where("open_id = ?", openId).Find(&users)
	if result.Error != nil {
		return UserModel{}, result.Error
	}

	// 如果没有找到用户，则创建新用户
	if len(users) == 0 {
		newUser := UserModel{
			OpenId:     openId,
			AvatarUrl:  avatarUrl,
			NickName:   nickName,
			IfVerified: 0,
		}

		if err := um.DB.Create(&newUser).Error; err != nil {
			return UserModel{}, err
		}
		return newUser, nil
	}

	// 如果用户已存在，直接返回
	return users[0], nil
}

func (um *UserModel) UpdateAvatarUrl(open_id string, url string) {
	um.DB.Model(&UserModel{}).Where("open_id = ?", open_id).Update("avatar_url", url)
}

// 获取用户的头像
func GetUserAvatar(openId string) string {
	var avatar string
	db := UseDbConn("")
	result := db.Model(&UserModel{}).Where("open_id = ?", openId).Pluck("avatar_url", &avatar)
	if result.Error != nil {
		variable.ZapLog.Error("无法找到用户头像", zap.String("open_id", openId), zap.Error(result.Error))
		return ""
	}
	return avatar
}

func GetCurrentTime() string {
	return time.Now().Format("2006-01-02 15:04:05")
}
